API:REST API/Referenzen

This page is a translated version of the page API:REST API/Reference and the translation is 79% complete.

Outdated translations are marked like this.

Die REST-API lässt dich durch das Absenden von HTTP-Abfragen an einzigartige URLs mit MediaWiki interagieren. Du kannst die API nutzen, um Apps und Skripte zu erstellen, die Wiki-Seiten und Versionsgeschichten durchsuchen.

Dokumentation

Anleitungen

Suche

MediaWiki Version:

≥ 1.35

Suchergebnisobjekt

Das Suchergebnisobjekt repräsentiert eine Wiki-Seite, die mit der angefragten Suche übereinstimmt.

Beispiel

{
  "id": 38930,
  "key": "Jupiter",
  "title": "Jupiter",
  "excerpt": "<span class=\"searchmatch\">Jupiter</span> is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half",
  "matched_title": null,
  "description": "fifth planet from the Sun and largest planet in the Solar System",
  "thumbnail": {
    "mimetype": "image/jpeg",
    "size": null,
    "width": 200,
    "height": 200,
    "duration": null,
    "url": "//upload.wikimedia.org/wikipedia/commons/thumb/2/2b/Jupiter_and_its_shrunken_Great_Red_Spot.jpg/200px-Jupiter_and_its_shrunken_Great_Red_Spot.jpg"
  }
}

Schema

`id` required \| integer	Seitenkennung
`key` required \| string	Seitentitel in URL-freundlichem Format
`title` required \| string	Seitentitel in lesefreundlichem Format
`excerpt` required \| string
`matched_title` optional \| string	Der Titel der Seite, von der aus weitergeleitet wird, wenn der Suchbegriff ursprünglich mit einer Weiterleitungsseite übereinstimmt oder null, wenn der Suchbegriff nicht mit einer Weiterleitungsseite übereinstimmt.
`description` required \| string
`thumbnail` required \| object	Information über das Vorschaubild der Seite oder `null`, wenn kein Vorschaubild existiert. `mimetype` (string): Medientyp des Vorschaubilds `size` (integer): Dateigröße in Bytes oder `null`, wenn nicht verfügbar `width` (integer): Maximale empfohlene Breite des Bildes in Pixeln oder `null`, wenn nicht verfügbar `height` (integer): Maximale empfohlene Höhe des Bildes in Pixeln oder `null`, wenn nicht verfügbar `duration` (integer): Länge des Videos, Audios oder der Multimedia-Datei oder `null` für andere Medientypen `url` (string): URL zum Herunterladen der Datei

Seiten suchen

Path	`/search/page?q=search terms`	Method	`GET`
Content type	`application/json`	Returns	`pages`-Objekt, das das Array der Suchergebnisse enthält

Sucht nach Titeln von Wiki-Seiten und Inhalten für die angegebenen Suchbegriffe und gibt passende Seiten aus.

Bei der Nutzung dieses Endpunktes in deinem Wiki
Dieser Endpunkt nutzt die Suchmaschine, die in den Konfigurationseinstellungen von $wgSearchType konfiguriert ist und gibt die Ergebnisse in den von $wgNamespacesToBeSearchedDefault konfigurierten Namensräumen aus.

Beispiele

curl

# Search English Wikipedia for up to 20 pages containing information about Jupiter
$ curl "https://en.wikipedia.org/w/rest.php/v1/search/page?q=jupiter&limit=20"

Python

# Search English Wikipedia for up to 20 pages containing information about Jupiter
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/search/page'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
    'q': 'jupiter',
    'limit': '20'
}

response = requests.get(url, headers=headers, params=params)
data = response.json()

print(data)

PHP

<?php
/*
Search English Wikipedia for up to 20 pages containing information about Jupiter
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/search/page";
$params = [ "q" => "jupiter", "limit" => "20" ];
$url = $url . "?" . http_build_query( $params );

$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Search English Wikipedia for up to 20 pages containing information about Jupiter
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/search/page";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  let params = {
    'q': 'jupiter',
    'limit': '20'
  };
  let query = Object.keys(params)
             .map(k => k + '=' + encodeURIComponent(params[k]))
             .join('&');
  url = url + '?' + query;

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`q` required \| query \| string	Suchbegriffe
`limit` optional \| query \| string	Maximale Anzahl auszugebender Ergebnisse, zwischen 1 und 100. Standard: 50.

Antworten

200	Erfolg: Ergebnisse gefunden. Gibt ein `pages`-Objekt aus, das ein Array der Suchergebnisse enthält.
200	Erfolg: Keine Ergebnisse gefunden. Gibt ein `pages`-Objekt aus, das ein leeres Array enthält.
400	Abfrage-Parameter nicht gesetzt. Setze den Parameter `q`.
400	Ungültiges Limit abgefragt. Setze den Parameter `limit` auf einen Wert zwischen 1 und 100.
500	Suchfehler

Automatische Vervollständigung des Seitentitels

Path	`/search/title?q=search terms`	Method	`GET`
Content type	`application/json`	Returns	`pages` object containing array of search results

Sucht Titel von Wiki-Seiten und gibt Treffer zwischen dem Beginn eines Titels und den angegebenen Suchbegriffen aus. Du kannst diesen Endpunkt für eine Typeahead-Suche nutzen, die automatisch relevante Seiten anhand ihres Titels vorschlägt.

Bei der Nutzung dieses Endpunktes in deinem Wiki
Dieser Endpunkt nutzt die Suchmaschine, die in den Konfigurationseinstellungen von $wgSearchType konfiguriert ist und gibt die Ergebnisse in den von $wgNamespacesToBeSearchedDefault konfigurierten Namensräumen aus. Die Ergebnisse können sich abhängig vom konfigurierten Such-Backend unterscheiden. Während das Standard-Backend nur grundlegendes Case-Folding und Präfix-Treffer anwendet, können fortgeschrittene Backends komplexere Variationen anwenden. Im Fall von CirrusSearch basieren Treffer beispielsweise auf dem Elastic-Search-Vervollständigungsvorschlag.

Beispiele

curl

# Search English Wikipedia for up to 5 pages with titles that start with "solar"
$ curl "https://en.wikipedia.org/w/rest.php/v1/search/title?q=solar&limit=5"

Python

# Search English Wikipedia for up to 5 pages with titles that start with "solar"
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/search/title'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
    'q': 'solar',
    'limit': '5'
}

response = requests.get(url, headers=headers, params=params)
data = response.json()

print(data)

PHP

<?php
/*
Search English Wikipedia for up to 5 pages with titles that start with "solar"
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/search/title";
$params = [ "q" => "solar", "limit" => "5" ];
$url = $url . "?" . http_build_query( $params );

$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Search English Wikipedia for up to 5 pages with titles that start with "solar"
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/search/title";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  let params = {
    'q': 'solar',
    'limit': '5'
  };
  let query = Object.keys(params)
             .map(k => k + '=' + encodeURIComponent(params[k]))
             .join('&');
  url = url + '?' + query;

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`q` required \| query \| string	Suchbegriffe
`limit` optional \| query \| string

Antworten

200
200
400
400
500

Seiten

MediaWiki Version:

≥ 1.35

Seiten-Objekt

Das Seiten-Objekt repräsentiert die letzte Version einer Wiki-Seite.

Beispiel

{
  "id": 9228,
  "key": "Earth",
  "title": "Earth",
  "latest": {
    "id": 963613515,
    "timestamp": "2020-06-20T20:05:55Z"
  },
  "content_model": "wikitext",
  "license": {
    "url": "//creativecommons.org/licenses/by-sa/3.0/",
    "title": "Creative Commons Attribution-Share Alike 3.0"
  },
  "html_url": "https://en.wikipedia.org/w/rest.php/v1/page/Earth/html"
}

Schema

`id` required \| integer	Seitenkennung
`key` required \| string	Seitentitel in URL-freundlichem Format
`title` required \| string	Seitentitel in lesefreundlichem Format
`latest` required \| object	Information über die letzte Version, darunter: `id` (integer): Versionskennung für die letzte Version `timestamp` (string): Zeitstempel der letzten Version im Format ISO 8601
`content_model` required \| string	Typ des Inhalts der Seite. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
`license` required \| map of strings	Information über die Lizenz des Wikis, darunter: `url` (string): URL der anwendbaren Lizenz, basierend auf der Einstellung $wgRightsUrl `title` (string): Name der anwendbaren Lizenz, basierend auf der Einstellung $wgRightsText
`html_url` required \| string (Get page only)	API-Pfad zum Erhalt des Inhalts der Seite in HTML
`html` required \| string (Nur beim Erhalten einer Seite only)
`source` required \| string (Nur beim Erhalt einer Quellseite, Erstellung einer Seite und Aktualisierung einer Seite only)	Letzter Seiteninhalt im Format, das von der Eigenschaft `content_model` angegeben wird

Seitensprachen-Objekt

Das Seitensprachen-Objekt repräsentiert eine Wiki-Seite und ihre Sprache.

Beispiel

{
  "code": "pl",
  "name": "polski",
  "key": "Ziemia",
  "title": "Ziemia"
}

Schema

`code` required \| string	Sprachcode. Siehe die Seiten-Matrix im Meta-Wiki für Wikimedia-Projekte.
`name` required \| string	Übersetzter Sprachenname
`key` required \| string	Übersetzter Seitentitel in URL-freundlichem Format
`title` required \| string	Übersetzter Seitentitel in lesefreundlichem Format

Seite erstellen

Path	`/page`	Method	`POST`
Accepts	`application/json`	Body	see schema below
Content type	`application/json`	Returns	Seiten-Objekt mit Eigenschaft `source`

Erstellt eine Wiki-Seite. Die Antwort umfasst einen location-Header, der den API-Endpunkt enthält, um die neue Seite zu erhalten.

Dieser Endpunkt wurde entworfen, um zusammen mit dem Autorisierungsprozess der OAuth-Erweiterung genutzt zu werden. Anrufer, die die Cookie-basierte Authentifizierung nutzen, müssen stattdessen ein CSRF-token zum Abfragekörper hinzufügen. Um ein CSRF-Token zu erhalten, siehe die Action API.

Beispiele

curl

# Create a user sandbox page on English Wikipedia
$ curl -X POST https://en.wikipedia.org/w/rest.php/v1/page -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" --data '{"source": "Hello, world!", "title": "User:<my username>/Sandbox", "comment": "Creating a test page with the REST API"}'

Python

# Create a user sandbox page on English Wikipedia
import requests
import json

url = 'https://en.wikipedia.org/w/rest.php/v1/page'

# Substitute your OAuth token
headers = {
    'User-Agent'   : 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)',
    'Content-Type' : 'application/json',
    'Authorization': 'Bearer $TOKEN'
}

# Substitute your username
request_data = {
    "source" : "Hello, world!",
    "title"  : "User:<my username>/Sandbox",
    "comment": "Creating a test page with the REST API"
}

response = requests.post( url, headers=headers, data = json.dumps(request_data) )
output = response.json()

print(output)

PHP

<?php
/*
Create a user sandbox page on English Wikipedia
*/

$url = 'https://en.wikipedia.org/w/rest.php/v1/page';

// Substitute your username
$fields = [
    'source' => 'Hello, world!',
    'title' => 'User:<my username>/Sandbox',
    'comment' => 'Creating a test page with the REST API'
];

$json = json_encode( $fields );

$token = 'YOUR_OAUTH_TOKEN'; // Substitute your OAuth token
$authorization = 'Authorization: Bearer ' . $token;

$ch = curl_init();

curl_setopt( $ch, CURLOPT_URL, $url );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $json );
curl_setopt( $ch, CURLOPT_HTTPHEADER, array( 'Content-Type: application/json' , $authorization ));
curl_setopt( $ch, CURLOPT_USERAGENT, 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)' );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );

$output = curl_exec( $ch );
curl_close( $ch );

echo( $output );
?>

JavaScript

/*  
    Create a user sandbox page on English Wikipedia

    Substitute your OAuth token for $TOKEN.
    Substitute your username for <my username>.
*/

async function doFetch() {
  const response = await fetch(
    "https://en.wikipedia.org/w/rest.php/v1/page",
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $TOKEN'
      },
      body: JSON.stringify({
        "source" : "Hello, world!",
        "title"  : "User:<my username>/Sandbox",
        "comment": "Creating a test page with the REST API"
      }),
      'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
    }
  );
  const data = await response.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Abfrage-Schema

`source` required \| string	Seiteninhalt im Format, das von der Eigenschaft `content_model` angegeben wird
`title` required \| string	Seitentitel. Siehe das Handbuch für Informationen über Seitentitel in MediaWiki.
`comment` required \| string	Grund für die Erstellung der Seite. Um zu erlauben, dass der Kommentar vom Server eingefügt wird, nutze `"comment": null`..
`content_model` optional \| string	Typ des Inhalts der Seite. Standardmäßig `wikitext`. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
`token` optional \| string	Zur Nutzung der Cookie-basierten Authentifizierung ist ein CSRF-Token erforderlich. Lasse diese Eigenschaft weg, wenn du OAuth nutzt.

Antworten

201	Erfolg: Seite erstellt. Gibt das Seiten-Objekt mit der Eigenschaft `source` aus.
400	`token` fehlt bei der Nutzung der Cookie-basierten Authentifizierung. Füge ein CSRF-Token zum Abfragekörper hinzu oder nutze den Prozess der OAuth-Autorisierung.
400	Ungültiges Inhaltsmodell. Schließe ein gültiges `content_model` basierend auf verfügbaren Content-Handlers ein.
409	Seite existiert bereits
415	Nicht unterstütztes Inhaltsmodell. Füge den Abfrage-Header `Content-Type: application/json` hinzu.

Eine Seite aktualisieren

Pfad	`/page/{title}`	Inhaltsmodell	`application/json`
Methode	`PUT`	Ausgabe	Seiten-Objekt mit Eigenschaft `source`

Aktualisiert oder erstellt eine Wiki-Seite. Dieser Endpunkt wurde entworfen, um zusammen mit dem Autorisierungsprozess der OAuth-Erweiterung genutzt zu werden. Anrufer, die die Cookie-basierte Authentifizierung nutzen, müssen stattdessen ein CSRF-token zum Abfragekörper hinzufügen. Um ein CSRF-Token zu erhalten, siehe die Action API.

Du benötigst die Kennung der letzten Version der Seite und die Quellseite. Rufe zunächst den Endpunkt an, um die Quellseite zu erhalten und nutze dann source und latest.id, um die Seite zu aktualisieren. Wenn latest.id nicht mit der letzten Version einer Seite übereinstimmt, löst die API Konflikte automatisch, sofern dies möglich ist. Im Fall eines Bearbeitungskonfliktes, gibt die API einen 409-Fehler aus.

Lasse latest.id bei der Abfrage weg, um eine Seite zu erstellen.

Beispiele

curl

# Update the sandbox page on English Wikipedia with "Hello, world!"
$ curl -X PUT https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" --data '{"source": "Hello, world!", "comment": "Testing out the REST API", "latest": { "id": 555555555 }}'

Python

# Update the sandbox page on English Wikipedia with "Hello, world!"
import requests
import json

url = "https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox"

# Substitute your OAuth token
headers = {
    "User-Agent" : "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)",
    "Content-Type" : "application/json",
    "Authorization" : "Bearer $TOKEN"
}

# Use the get page endpoint to get the latest revision ID
request_data = {
    "source" : "Hello, world!",
    "comment": "Testing out the REST API",
    "latest" : { "id": 555555555 }
}

response = requests.put( url, headers=headers, data = json.dumps(request_data) )
output = response.json()

print(output)

PHP

<?php
/*
Update the sandbox page on English Wikipedia with "Hello, world!"
*/

$page = 'Wikipedia:Sandbox';
$endpoint = 'https://en.wikipedia.org/w/rest.php/v1/page/';
$url = $endpoint . $page;

// Use the get page endpoint to get the latest revision ID
$fields = [
    'source' => 'Hello, world!',
    'comment' => 'Testing out the REST API',
    'latest' => [
        'id' => 555555555
    ]
];

$json = json_encode( $fields );

$token = 'YOUR_OAUTH_TOKEN'; // Substitute your OAuth token
$authorization = 'Authorization: Bearer ' . $token;

$ch = curl_init();

curl_setopt( $ch, CURLOPT_URL, $url );
curl_setopt( $ch, CURLOPT_CUSTOMREQUEST, 'PUT' );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $json );
curl_setopt( $ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json' , $authorization ));
curl_setopt( $ch, CURLOPT_USERAGENT, 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)' );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true ); 

$output = curl_exec( $ch );
curl_close( $ch );

echo( $output );
?>

JavaScript

/*  
    Update the sandbox page on English Wikipedia with "Hello, world!"

    Substitute your OAuth token for $TOKEN.
    Use the get page endpoint to get the latest revision ID.
*/

async function doFetch() {
  const response = await fetch(
    "https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox",
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $TOKEN'
      },
      body: JSON.stringify({
        "source": "Hello, world!",
        "comment": "Testing out the REST API",
        "latest": { "id": 555555555 }
      }),
      'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
    }
  );
  const data = await response.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Parameter

`title` required \| path	Titel der Wiki-Seite

Abfrage-Schema

`source` required \| string	Seiteninhalt im Format, das von der Eigenschaft `content_model` angegeben wird
`comment` required \| string	Zusammenfassung der Bearbeitung. Um zu erlauben, dass der Kommentar vom Server eingefügt wird, nutze `"comment": null`.
`latest` optional \| object	Objekt, das die Basis-Version der Bearbeitung identifiziert. Du kannst diese Information aus dem Endpunkt zum Erhalt der Quellseite erhalten.
`latest.id` optional \| integer	Identifikator für die Version, die als Basis für die neue `source` genutzt wird, erfordert die Aktualisierung einer existierenden Seite. Lasse diese Eigenschaft weg, um eine neue Seite zu erstellen.
`content_model` optional \| string	Typ des Inhalts der Seite. Standardmäßig `wikitext` für neue Seiten oder das Inhaltsmodell der existierenden Seite. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
`token` optional \| string	Zur Nutzung der Cookie-basierten Authentifizierung ist ein CSRF-Token erforderlich. Lasse diese Eigenschaft weg, wenn du OAuth nutzt.

Antworten

200	Erfolg: Seite aktualisiert. Gibt das Seiten-Objekt mit der Eigenschaft `source` aus.
201	Erfolg: Seite aktualisiert. Gibt das Seiten-Objekt mit der Eigenschaft `source` aus.
400	`token` fehlt bei der Nutzung der Cookie-basierten Authentifizierung. Füge ein CSRF-Token zum Abfragekörper hinzu oder nutze den Prozess der OAuth-Autorisierung.
400	Ungültiges Inhaltsmodell. Stelle sicher, dass die Eigenschaft `content_model` im Abfragekörper mit dem `content_model` der Zielseite übereinstimmt.
409	Seite existiert bereits. Gib die Kennung der grundlegenden Version in `latest.id` im Abfragekörper an, um die existierende Seite zu aktualisieren.
409	Bearbeitungskonflikt. Der Fehler enthält die Unterschiede zwischen der in der Abfrage angegebenen grundlegenden Version und der letzten veröffentlichten Version. Siehe die Wikidiff2-Dokumentation für Informationen über das Format des Versionsunterschieds. Erfordert die Wikidiff2-Erweiterung 1.10+.
415	Nicht unterstütztes Inhaltsmodell. Füge den Abfrage-Header `Content-Type: application/json` hinzu.

Seite erhalten

Pfad	`/page/{title}/bare`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Seiten-Objekt mit Eigenschaft `html_url`

Gibt das Standard-Seiten-Objekt für eine Wiki-Seite mit dem API-Pfad zum Erhalt des letzten Inhalts in HTML, der Lizenz und Informationen über die letzte Version aus.

Beispiele

curl

# Get information about the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare"

Python

# Get information about the Jupiter article on English Wikipedia
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get information about the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get information about the Jupiter article on English Wikipedia
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite

Antworten

200	Erfolg: Seite gefunden. Gibt die Seite mit der Eigenschaft `html_url` aus.
301
404	Titel oder Version nicht gefunden

Seite offline erhalten

Pfad	`/page/{title}/with_html`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Seiten-Objekt mit Eigenschaft `html`

Gibt Informationen über eine Wiki-Seite aus, darunter die Lizenz, die letzte Version und der letzte Inhalt in HTML.

Beispiele

curl

# Get HTML and metadata for the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html"

Python

# Get HTML and metadata for the Jupiter article on English Wikipedia
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get HTML and metadata for the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get HTML and metadata for the Jupiter article on English Wikipedia
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path \| string	Titel der Wiki-Seite
`redirect` optional \| query \| bool

Antworten

200
301
307
404

Quellseite erhalten

Pfad	`/page/{title}`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Seiten-Objekt mit Eigenschaft `source`

Gibt den Inhalt einer Wiki-Seite im durch die Eigenschaft content_model angegebenen Format, die Lizenz und Informationen über die letzte Version aus.

Beispiele

curl

# Get source and metadata for the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter"

Python

# Get source and metadata for the Jupiter article on English Wikipedia
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get source and metadata for the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get source and metadata for the Jupiter article on English Wikipedia
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite

Antworten

200
301
404

HTML erhalten

Pfad	`/page/{title}/html`	Inhaltsmodell	`text/html`
Methode	`GET`	Ausgabe	Seiten-HTML im HTML-2.1.0-Format

Gibt den letzten Inhalt einer Wiki-Seite in HTML aus.

Beispiele

curl

# Get the content of the Jupiter article on English Wikipedia in HTML
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html"

Python

# Get the content of the Jupiter article on English Wikipedia in HTML
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get the content of the Jupiter article on English Wikipedia in HTML
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get the content of the Jupiter article on English Wikipedia in HTML
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path \| string
`redirect` optional \| query \| bool

Antworten

200
301
307
404

Sprachen erhalten

Pfad	`/page/{title}/links/language`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Array von Seitensprachen

Durchsucht verbundene Wikis nach Seiten mit dem gleichen Thema in einer anderen Sprache. Gibt ein Array der Seitensprachen-Objekte aus, das den Namen der Sprache, den Sprachcode und den übersetzten Seitentitel enthält. Returns an array of page language objects that include the name of the language, the language code, and the translated page title.

Beispiele

curl

# Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language"

Python

# Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite

Antworten

200	Erfolg: Sprachen gefunden. Gibt ein Array der Seitensprachen aus.
404	Titel nicht gefunden

Dateien von einer Seite erhalten

Pfad	`/page/{title}/links/media`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	`files`-Objekt, das das Array der Dateien enthält

Gibt Informationen über Mediendateien aus, die auf einer Wiki-Seite genutzt werden.

Beispiele

curl

# Get media files used on the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media"

Python

# Get media files used on the Jupiter article on English Wikipedia
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get media files used on the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get media files used on the Jupiter article on English Wikipedia
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite

Antworten

200	Erfolg: Mediendateien gefunden. Gibt ein `files`-Objekt aus, das ein Array der Dateien enthält.
200	Erfolg: Keine Mediendateien gefunden. Gibt ein `files`-Objekt aus, das ein leeres Array enthält.
404	Titel nicht gefunden
400	Seite enthält mehr als 100 Mediendateien

Transform

MediaWiki Version:

≥ 1.41

The transform endpoint provides on-the-fly round-trip conversion between wikitext and HTML.

This documentation does not yet cover all available features of the transform endpoint. See the documentation for the older RESTBase endpoint for additional information: https://en.wikipedia.org/api/rest_v1/#/Transforms

Convert Wikitext to HTML

Pfad	`/transform/wikitext/to/html/{title}`	Content type	`application/json`
Methode	`POST`	Payload	Transform request body with `source`
Returns	an HTML document.

Converts wikitext to HTML.

Examples

curl

# Render wikitext in the context of the Jupiter page on English Wikipedia, without modifying the page:
$ curl -X POST -H "Content-Type: application/json" --data '{ "wikitext": "== Hello Jupiter ==" }' 'https://en.wikipedia.org/w/rest.php/v1/transform/wikitext/to/html/Jupiter'

Parameters

`title` required \| path	Wiki page title, used for context

Responses

200	Success: the response body contains the rendered HTML.

Convert HTML to Wikitext

Pfad	`/transform/html/to/wikitext/{title}`	Content type	`application/json`
Methode	`POST`	Payload	Transform request body with `HTML`
Returns	a wikitext document.

Converts wikitext to HTML.

Beispiele

curl

# Generate wikitext from HTML, in the context of the Jupiter page on English Wikipedia:
$ curl -X POST -H "Content-Type: application/json" --data '{ "html": "<h2> hello World </h2>" }' 'https://en.wikipedia.org/w/rest.php/v1/transform/html/to/wikitext/Jupiter'

Parameter

`title` required \| path	Wiki page title, used for context

Antworten

200	Success: the response body contains the wikitext.

Transform request body

Payload structure for transform requests.

Example

For converting wikitext to HTML:

{
  "wikitext": "Hello World"
}

For converting HTML to Wikitext:

{
  "html": "<h2>Hello World</h2>"
}

Mediendateien

MediaWiki Version:

≥ 1.35

Datei-Objekt

Das Datei-Objekt repräsentiert eine Datei, die in einem Wiki hochgeladen wurde.

Beispiel

{
  "title": "The Blue Marble.jpg",
  "file_description_url": "//commons.wikimedia.org/wiki/File:The_Blue_Marble.jpg",
  "latest": {
    "timestamp": "2011-12-07T05:11:41Z",
    "user": {
      "id": 811185,
      "name": "Ultimate Roadgeek"
    }
  },
  "preferred": {
    "mediatype": "BITMAP",
    "size": null,
    "width": 599,
    "height": 599,
    "duration": null,
    "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/The_Blue_Marble.jpg/599px-The_Blue_Marble.jpg"
  },
  "original": {
    "mediatype": "BITMAP",
    "size": 7011595,
    "width": 3000,
    "height": 3002,
    "duration": null,
    "url": "https://upload.wikimedia.org/wikipedia/commons/7/78/The_Blue_Marble.jpg"
  },
  "thumbnail": {
    "mediatype": "BITMAP",
    "size": null,
    "width": 1023,
    "height": 1024,
    "duration": null,
    "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/The_Blue_Marble.jpg/1023px-The_Blue_Marble.jpg"
  }
}

Schema

`title` required \| string	Dateititel
`file_description_url` required \| string	URL für die Seite, die die Datei beschreibt, inklusive Lizenzinformationen und anderen Metadaten
`latest` required \| object	Objekt, das Informationen über die letzte Version der Datei enthält, darunter: `timestamp` (string): Zeitstempel der letzten Änderung im Format ISO 8601 `user` (object): Objekt, das Informationen über den Benutzer enthält, der die Datei hochgeladen hat `id` (integer): Benutzerkennung `name` (string): Benutzername
`preferred` required \| object	Informationen über das bevorzugte Vorschauformat der Datei, das originale Format und das Miniaturformat, darunter: `mediatype` (string): Der Dateityp, einer von: BITMAP, DRAWING, AUDIO, VIDEO, MULTIMEDIA, UNKNOWN, OFFICE, TEXT, EXECUTABLE, ARCHIVE oder 3D `size` (integer): Dateigröße in Bytes oder `null`, wenn nicht verfügbar `width` (integer): Maximale empfohlene Breite des Bildes in Pixeln oder `null`, wenn nicht verfügbar `height` (integer): Maximale empfohlene Höhe des Bildes in Pixeln oder `null`, wenn nicht verfügbar `duration` (integer): Länge des Videos, Audios oder der Multimedia-Datei oder `null` für andere Medientypen `url` (string): URL zum Herunterladen der Datei
`original` required \| object
Nur beim Erhalten einer Datei `thumbnail` required \| object

Datei erhalten

Pfad	`/file/{title}`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Datei

Gibt Informationen über eine Datei aus, darunter Links zum Herunterladen der Datei im Miniaturformat, Vorschauformat und originalen Format.

Beispiele

curl

# Get File:The_Blue_Marble.jpg on Wikimedia Commons
$ curl "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg"

Python

# Get File:The_Blue_Marble.jpg on Wikimedia Commons
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get File:The_Blue_Marble.jpg on Wikimedia Commons
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get File:The_Blue_Marble.jpg on Wikimedia Commons
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

Parameter	Beschreibung
`title` required \| path	Dateititel

Antworten

200	Erfolg: Datei gefunden. Gibt die Datei aus.
404	Titel nicht gefunden

Versionsgeschichte

MediaWiki Version:

≥ 1.35

Versionsobjekt

Das Versionsobjekt repräsentiert eine Änderung auf einer Wiki-Seite.

Beispiel

{
  "id": 931281281,
  "page": {
    "id": 38930,
    "title": "Jupiter"
  },
  "size": 126009,
  "minor": false,
  "timestamp": "2019-12-18T01:39:24Z",
  "user": {
    "id": 27015025,
    "name": "InternetArchiveBot"
  },
  "comment": "Bluelinking 2 books for [[WP:V|verifiability]].) #IABot (v2.1alpha3",
  "delta": 231
}

Schema

`id` required \| integer	Versionsidentifikator
Nur beim Erhalten einer Version `page` required \| object	Objekt, das Informationen über die Seite enthält, darunter: `page_id` (integer): Seitenkennung `title` (string): Seitentitel in lesefreundlichem Format
`user` required \| object	Objekt, das Informationen über den Benutzer enthält, der die Bearbeitung vorgenommen hat, darunter: `name` (string): Benutzername `id` (integer): Benutzerkennung Für unangemeldete Benutzer enthält `name` die originale IP-Adresse und `id` ist `null`.
`timestamp` required \| string	Zeitstempel der Bearbeitung im Format ISO 8601
`comment` required \| string	Kommentar oder Bearbeitungszusammenfassung des Autors. Für Versionen ohne einen Kommentar gibt die API `null` oder `""` aus.
`size` required \| integer	Größe der Version in Bytes
`delta` required \| integer	Anzahl der geänderten Bytes, positiv oder negativ, zwischen einer Version und der älteren Version (Beispiel: `-20`). Wenn die ältere Version nicht verfügbar ist, gibt die API `null` aus.
`minor` required \| boolean	true für Bearbeitungen, die als klein markiert wurden
`html_url` required \| string (Get revision only)
`html` required \| string (Get revision with HTML only)
`source` required \| string (Get revision source only)

Versionsgeschichte erhalten

Pfad	`/page/{title}/history`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Bereich der Versionsgeschichte

Gibt Informationen über die letzten Versionen einer Wiki-Seite in Bereichen von 20 Versionen, beginnend mit der letzten Version, aus. Die Antwort enthält API-Pfade für die nächstälteren, nächstneueren und die neuesten Versionsbereiche und ermöglicht es dir so, durch die Versionsgeschichte zu scrollen.

Beispiele

curl

# Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history?filter=bot&older_than=939967546"

Python

# Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
    'filter': 'bot',
    'older_than': '939967546'
}

response = requests.get(url, headers=headers, params=params)
data = response.json()

print(data)

PHP

<?php
/*
Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history";
$params = [ "filter" => "bot", "older_than" => "939967546" ];
$url = $url . "?" . http_build_query( $params );

$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  let params = {
    'filter': 'bot',
    'older_than': '939967546'
  };
  let query = Object.keys(params)
             .map(k => k + '=' + encodeURIComponent(params[k]))
             .join('&');
  url = url + '?' + query;

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite
`older_than` optional \| query	Akzeptiert eine Versionskennung. Gibt die 20 nächstälteren Versionen der angegebenen Versionskennung aus.
`newer_than` optional \| query	Akzeptiert eine Versionskennung. Gibt die 20 nächstneueren Versionen der angegebenen Versionskennung aus.
`filter` optional \| query	Filter, der nur Versionen mit bestimmten Markierungen ausgibt. Eine von: `reverted`: Gibt nur Versionen aus, die eine frühere Bearbeitung rückgängig machen `anonymous`: Gibt nur Versionen von unangemeldeten Benutzern aus `bot`: Gibt nur Versionen von Bots aus `minor`: Gibt nur Versionen aus, die als kleine Bearbeitungen markiert sind Die API unterstützt einen Filter je Abfrage.

Antworten

200	Erfolg: Versionen gefunden. Gibt einen Bereich der Versionsgeschichte aus.
200	Erfolg: Keine Versionen gefunden. Gibt einen Bereich der Versionsgeschichte mit einem leeren Array `revisions` aus.
400	Versionskennung muss größer als 0 sein
400	Die Parameter `older_than` und `newer_than` können nicht beide zusammen angegeben werden
400	Ungültiger Parameter
404	Titel oder Version nicht gefunden

Antwort-Schema

`latest` required \| string	API-Pfad, um die letzten Versionen zu erhalten
`older` optional \| string	API-Pfad zum Erhalt der älteren Versionen, sofern verfügbar
`newer` optional \| string	API-Pfad zum Erhalt der neueren Versionen, sofern verfügbar
`revisions` required \| array	Array von 0-20 Versionsobjekten

Versionszähler erhalten

Pfad	`/page/{title}/history/counts/{type}`	Inhaltsmodell	`application/json`
Methode	`GET`	Ausgabe	Versionszähler-Objekt

Gibt Daten über die Versionsgeschichte einer Seite aus.

Beispiele

curl

# Get the number of edits to a page between revisions 384955912 and 406217369
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits?from=384955912&to=406217369"

Python

# Get the number of edits to a page between revisions 384955912 and 406217369
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
    'from': '384955912',
    'to': '406217369'
}

response = requests.get(url, headers=headers, params=params)
data = response.json()

print(data)

PHP

<?php
/*
Get the number of edits to a page between revisions 384955912 and 406217369
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits";
$params = [ "from" => "384955912", "to" => "406217369" ];
$url = $url . "?" . http_build_query( $params );

$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get the number of edits to a page between revisions 384955912 and 406217369
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  let params = {
    'from': '384955912',
    'to': '406217369'
  };
  let query = Object.keys(params)
             .map(k => k + '=' + encodeURIComponent(params[k]))
             .join('&');
  url = url + '?' + query;

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`title` required \| path	Titel der Wiki-Seite
`type` required \| path	Typ des Zählers. Einer von: `anonymous`: Bearbeitungen von unangemeldeten Benutzern. Limit: 10.000 `bot`: Bearbeitungen von Bots. Limit: 10.000 `editors`: Benutzer oder Bots, die eine Seite bearbeitet haben. Limit: 25.000 `edits`: Jede Änderung am Seiteninhalt. Limit: 30.000 `minor`: Als klein markierte Bearbeitungen. Wenn der Zähler für kleine Bearbeitungen 2.000 übersteigt, gibt die API einen Fehler 500 aus. Limit: 1.000 `reverted`: Bearbeitungen, die eine frühere Bearbeitung rückgängig machen. Limit: 30.000
`from` optional \| query	Nur für die Typen `edits` und `editors` Begrenzt den Zähler zwischen zwei Versionen, angegeben durch Versionskennungen. Die Abfrageparameter `from` und `to` müssen als Paar genutzt werden. Das Ergebnis die Bearbeitungen oder Autoren aus, die durch die Versionen `from` und `to` repräsentiert werden.
`to` optional \| query

Antworten

200	Erfolg
400	Ungültiger Parameter oder Kombination von Parametern
404	Titel oder Version nicht gefunden
500	Zähler kleiner Bearbeitungen übersteigt 2.000

Antwort-Schema

`count` required \| integer	Der Wert des Datenpunktes bis zum Limit des Typs. Wenn der Wert das Limit übersteigt, gibt die API das Limit als Wert von `count` aus und setzt die Eigenschaft `limit` auf true.
`limit` required \| boolean	Gibt true aus, wenn der Datenpunkt das Limit des Typs übersteigt.

Version erhalten

Path	`revision/{id}/bare`	Method	`GET`
Content type	`application/json`	Returns	Version

Gibt Details für eine einzelne Version aus.

Beispiele

curl

# Get information about revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare"

Python

# Get information about revision 764138197
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get information about revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get information about revision 764138197
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`id` required \| path \| string	Versionskennung

Antworten

200	Erfolg: Version gefunden. Gibt eine Version aus.
404

Get revision source

Path	`revision/{id}`	Method	`GET`
Content type	`application/json`	Returns	Revision

Returns details for an individual revision.

Examples

curl

# Get the wikitext of revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197"

Python

# Get the wikitext of revision 764138197
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get the wikitext of revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get the wikitext of revision 764138197
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

https://en.wikipedia.org/w/rest.php/v1/revision/764138197

Parameters

`id` required \| path \| string

Responses

200
404	Version nicht gefunden

Get revision HTML

Path	`revision/{id}/html`	Method	`GET`
Content type	`text/HTML`	Returns	Revision

Returns HTML for an individual revision.

Examples

curl

# Get HTML of revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html"

Python

# Get HTML of revision 764138197
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get HTML of revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get HTML of revision 764138197
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html

Parameters

`id` required \| path \| string

Responses

200
404

Get revision information with HTML

Path	`revision/{id}/with_html`	Method	`GET`
Content type	`application/json`	Returns	Revision

Returns HTML and meta-data for an individual revision.

Examples

curl

# Get information about revision 764138197 along with rendered HTML
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html"

Python

# Get information about revision 764138197 along with rendered HTML
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Get information about revision 764138197 along with rendered HTML
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Get information about revision 764138197 along with rendered HTML
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html

Parameters

`id` required \| path \| string

Responses

200
404

Versionen vergleichen

Pfad	`revision/{from}/compare/{to}`	Inhaltsmodell	`application/json`
Methoden	`GET`	Ausgabe	Wikidiff2-JSON-Versionsunterschiedsformat

Gibt Daten aus, die dich Zeile für Zeile zwei Versionen vergleichen lassen. (Siehe ein Beispiel.) Nur textbasierte Wiki-Seiten können verglichen werden.

Um diesen Endpunkt in deinem Wiki zu nutzen
Installiere Wikidiff2 1.9.0 oder neuer.

Beispiele

curl

# Compare revision 847170467 to 851733941
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941"

Python

# Compare revision 847170467 to 851733941
import requests

url = 'https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941'
headers = {
    'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}


response = requests.get(url, headers=headers)
data = response.json()

print(data)

PHP

<?php
/*
Compare revision 847170467 to 851733941
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941";


$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );

echo($output);
?>

JavaScript

/*  
    Compare revision 847170467 to 851733941
*/
async function doFetch() {
  let url = "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941";
  let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
  

  const rsp = await fetch(url, headers);
  const data = await rsp.json();
  return data;
}

async function fetchAsync()
{
  try {
    let result = await doFetch();
    console.log(result);
  } catch( err ) {
    console.error( err.message );
  }
}

fetchAsync();

Versuche es

Parameter

`from` required \| path	Versionskennung, die als Basis für den Vergleich dient
`to` required \| path	Versionskennung, mit der die Basis verglichen werden soll

Antworten

200	Erfolg: Versionen gefunden
400	Versionskennungen beziehen sich auf unterschiedliche Seiten oder auf Seiten, die nicht verglichen werden können
400	Ungültiges Inhaltsmodell
403	Version nicht öffentlich zugänglich
404	Version nicht gefunden
500	Wikidiff2-Erweiterung 1.9.0 oder neuer nicht installiert

Antwort-Schema

`from` required \| object	Information über die Basis-Version, die im Vergleich genutzt wird
`to` required \| object	Information über die Version, die mit der Basis-Version verglichen wird
`from.id` `to.id` required \| integer	Versionsidentifikator
`from.slot_role` `to.slot_role` required \| string	Bereich der Seite, der verglichen wird, normalerweise `main`
`from.sections` `to.sections` required \| array	Array von Objekten, die Abschnittsüberschriften repräsentieren, darunter: `level` (integer): Überschriftslevel, 1 bis 4 `heading` (string): Text der Überschriftszeile, in Wikitext `offset` (integer): Ort der Überschrift, in Bytes vom Anfang der Seite
`diff` required \| array of objects	Each object in the `diff` array represents a line in a visual, line-by-line comparison between the two revisions.
`diff.type` required \| integer	The type of change represented by the diff object, either: `0`: A line with the same content in both revisions, included to provide context when viewing the diff. The API returns up to two context lines around each change. `1`: A line included in the `to` revision but not in the `from` revision. `2`: A line included in the `from` revision but not in the `to` revision. `3`: A line containing text that differs between the two revisions. (For changes to paragraph location as well as content, see type 5.) `4`: When a paragraph's location differs between the two revisions, a type 4 object represents the location in the `from` revision. `5`: When a paragraph's location differs between the two revisions, a type 5 object represents the location in the `to` revision. This type can also include word-level differences between the two revisions.
`diff.lineNumber` optional \| integer	The line number of the change based on the `to` revision.
`diff.text` required \| string	The text of the line, including content from both revisions. For a line containing text that differs between the two revisions, you can use `highlightRanges` to visually indicate added and removed text. For a line containing a new line, the API returns the text as `""` (empty string).
`diff.highlightRanges` optional \| array of objects	An array of objects that indicate where and in what style text should be highlighted to visually represent changes. Each object includes: `start` (integer): Where the highlighted text should start, in the number of bytes from the beginning of the line. `length` (integer): The length of the highlighted section, in bytes. `type` (integer): The type of highlight: `0` indicates an addition. `1` indicates a deletion.
`diff.moveInfo` optional \| object	Visual indicators to use when a paragraph's location differs between the two revisions. `moveInfo` objects occur in pairs within the diff. `id` (string): The ID of the paragraph described by the diff object. `linkId` (string): The ID of the corresponding paragraph. For type 4 diff objects, `linkId` represents the location in the `to` revision. For type 5 diff objects, `linkId` represents the location in the `from` revision. `linkDirection` (integer): A visual indicator of the relationship between the two locations. You can use this property to display an arrow icon within the diff. `0` indicates that the `linkId` paragraph is lower on the page than the `id` paragraph. `1` indicates that the `linkId` paragraph is higher on the page than the `id` paragraph.
`diff.offset` required \| object	The location of the line in bytes from the beginning of the page, including: `from` (integer): The first byte of the line in the `from` revision. A `null` value indicates that the line doesn't exist in the `from` revision. `to` (integer): The first byte of the line in the `to` revision. A `null` value indicates that the line doesn't exist in the `to` revision.

`id` required \| integer	Seitenkennung
`key` required \| string	Seitentitel in URL-freundlichem Format
`title` required \| string	Seitentitel in lesefreundlichem Format
`excerpt` required \| string
`matched_title` optional \| string	Der Titel der Seite, von der aus weitergeleitet wird, wenn der Suchbegriff ursprünglich mit einer Weiterleitungsseite übereinstimmt oder null, wenn der Suchbegriff nicht mit einer Weiterleitungsseite übereinstimmt.
`description` required \| string
`thumbnail` required \| object	Information über das Vorschaubild der Seite oder `null`, wenn kein Vorschaubild existiert. `mimetype` (string): Medientyp des Vorschaubilds `size` (integer): Dateigröße in Bytes oder `null`, wenn nicht verfügbar `width` (integer): Maximale empfohlene Breite des Bildes in Pixeln oder `null`, wenn nicht verfügbar `height` (integer): Maximale empfohlene Höhe des Bildes in Pixeln oder `null`, wenn nicht verfügbar `duration` (integer): Länge des Videos, Audios oder der Multimedia-Datei oder `null` für andere Medientypen `url` (string): URL zum Herunterladen der Datei

`id` required \| integer	Seitenkennung
`key` required \| string	Seitentitel in URL-freundlichem Format
`title` required \| string	Seitentitel in lesefreundlichem Format
`latest` required \| object	Information über die letzte Version, darunter: `id` (integer): Versionskennung für die letzte Version `timestamp` (string): Zeitstempel der letzten Version im Format ISO 8601
`content_model` required \| string	Typ des Inhalts der Seite. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
`license` required \| map of strings	Information über die Lizenz des Wikis, darunter: `url` (string): URL der anwendbaren Lizenz, basierend auf der Einstellung $wgRightsUrl `title` (string): Name der anwendbaren Lizenz, basierend auf der Einstellung $wgRightsText
`html_url` required \| string (Get page only)	API-Pfad zum Erhalt des Inhalts der Seite in HTML
`html` required \| string (Nur beim Erhalten einer Seite only)
`source` required \| string (Nur beim Erhalt einer Quellseite, Erstellung einer Seite und Aktualisierung einer Seite only)	Letzter Seiteninhalt im Format, das von der Eigenschaft `content_model` angegeben wird

`title` required \| string	Dateititel
`file_description_url` required \| string	URL für die Seite, die die Datei beschreibt, inklusive Lizenzinformationen und anderen Metadaten
`latest` required \| object	Objekt, das Informationen über die letzte Version der Datei enthält, darunter: `timestamp` (string): Zeitstempel der letzten Änderung im Format ISO 8601 `user` (object): Objekt, das Informationen über den Benutzer enthält, der die Datei hochgeladen hat `id` (integer): Benutzerkennung `name` (string): Benutzername
`preferred` required \| object	Informationen über das bevorzugte Vorschauformat der Datei, das originale Format und das Miniaturformat, darunter: `mediatype` (string): Der Dateityp, einer von: BITMAP, DRAWING, AUDIO, VIDEO, MULTIMEDIA, UNKNOWN, OFFICE, TEXT, EXECUTABLE, ARCHIVE oder 3D `size` (integer): Dateigröße in Bytes oder `null`, wenn nicht verfügbar `width` (integer): Maximale empfohlene Breite des Bildes in Pixeln oder `null`, wenn nicht verfügbar `height` (integer): Maximale empfohlene Höhe des Bildes in Pixeln oder `null`, wenn nicht verfügbar `duration` (integer): Länge des Videos, Audios oder der Multimedia-Datei oder `null` für andere Medientypen `url` (string): URL zum Herunterladen der Datei
`original` required \| object
Nur beim Erhalten einer Datei `thumbnail` required \| object

`id` required \| integer	Versionsidentifikator
Nur beim Erhalten einer Version `page` required \| object	Objekt, das Informationen über die Seite enthält, darunter: `page_id` (integer): Seitenkennung `title` (string): Seitentitel in lesefreundlichem Format
`user` required \| object	Objekt, das Informationen über den Benutzer enthält, der die Bearbeitung vorgenommen hat, darunter: `name` (string): Benutzername `id` (integer): Benutzerkennung Für unangemeldete Benutzer enthält `name` die originale IP-Adresse und `id` ist `null`.
`timestamp` required \| string	Zeitstempel der Bearbeitung im Format ISO 8601
`comment` required \| string	Kommentar oder Bearbeitungszusammenfassung des Autors. Für Versionen ohne einen Kommentar gibt die API `null` oder `""` aus.
`size` required \| integer	Größe der Version in Bytes
`delta` required \| integer	Anzahl der geänderten Bytes, positiv oder negativ, zwischen einer Version und der älteren Version (Beispiel: `-20`). Wenn die ältere Version nicht verfügbar ist, gibt die API `null` aus.
`minor` required \| boolean	true für Bearbeitungen, die als klein markiert wurden
`html_url` required \| string (Get revision only)
`html` required \| string (Get revision with HTML only)
`source` required \| string (Get revision source only)

`title` required \| path	Titel der Wiki-Seite
`type` required \| path	Typ des Zählers. Einer von: `anonymous`: Bearbeitungen von unangemeldeten Benutzern. Limit: 10.000 `bot`: Bearbeitungen von Bots. Limit: 10.000 `editors`: Benutzer oder Bots, die eine Seite bearbeitet haben. Limit: 25.000 `edits`: Jede Änderung am Seiteninhalt. Limit: 30.000 `minor`: Als klein markierte Bearbeitungen. Wenn der Zähler für kleine Bearbeitungen 2.000 übersteigt, gibt die API einen Fehler 500 aus. Limit: 1.000 `reverted`: Bearbeitungen, die eine frühere Bearbeitung rückgängig machen. Limit: 30.000
`from` optional \| query	Nur für die Typen `edits` und `editors` Begrenzt den Zähler zwischen zwei Versionen, angegeben durch Versionskennungen. Die Abfrageparameter `from` und `to` müssen als Paar genutzt werden. Das Ergebnis die Bearbeitungen oder Autoren aus, die durch die Versionen `from` und `to` repräsentiert werden.
`to` optional \| query