API:Login
Outdated translations are marked like this.
 | Diese Seite ist Teil der Dokumentation der MediaWiki action API. |
MediaWiki API kann von Deiner Applikation oder Deinem Client verlangen, authentifizierte Benutzer-Credentials für (a) Query-Informationen oder datenmodifizierende Aktionen (b) die große Queries mit höheren Request-per-Limits vorzuweisen.
Zwei Methoden für die Authentifizierung
Es gibt zwei Methoden, um sich bei der MediaWiki-Action-API zu authentifizieren: mit action=login oder action=clientlogin.
For most modern clients and applications, action=clientlogin is recommended.
See the end-to-end clientlogin example including token retrieval and follow-up handling.
Methode 1. action=login
Bot- und andere nicht interaktive Applikationen sollten, wenn verfügbar, owner-only OAuth consumers verwenden, weil das sicherer ist.
Wenn nicht verfügbar oder mit dem Client nicht anwendbar, kann die login-Action mit Botpasswörtern verwendet werden.
API-Dokumentation
Beispiel
POST-Anfrage
api.php?
lgtoken in in der obigen Abfrage wird abgerufen aus API:Tokens
Antwort
{
"login": {
"lguserid": 21,
"result": "Success",
"lgusername": "William"
}
}
Beispielcode
MediaWiki JS
/*
login.js
MediaWiki API Demos
Demo of `Login` module: Sending request to login
MIT License
*/
var api = new mw.Api();
api.login( 'your_bot_username', 'your_bot_password' ).done( function ( data ) {
console.log( 'You are logged in as ' + data.login.lgusername );
} );
JavaScript
/*
edit.js
MediaWiki API Demos
Demo of `Login` module: Sending post request to login
MIT license
*/
var request = require( 'request' ).defaults( { jar: true } ),
url = 'https://test.wikipedia.org/w/api.php';
// Step 1: GET request to fetch login token
function getLoginToken() {
var params = {
action: 'query',
meta: 'tokens',
type: 'login',
format: 'json'
};
request.get( { url: url, qs: params }, function ( error, res, body ) {
var data;
if ( error ) {
return;
}
data = JSON.parse( body );
loginRequest( data.query.tokens.logintoken );
} );
}
// Step 2: POST request to log in.
// Use of main account for login is not
// supported. Obtain credentials via Special:BotPasswords
// (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
function loginRequest( loginToken ) {
var params = {
action: 'login',
lgname: 'bot_username',
lgpassword: 'bot_password',
lgtoken: loginToken,
format: 'json'
};
request.post( { url: url, form: params }, function ( error, res, body ) {
if ( error ) {
return;
}
console.log( body );
} );
}
// Start From Step 1
getLoginToken();
PHP
<?php
/*
login.php
MediaWiki API Demos
Demo of `Login` module: Sending post request to login
MIT license
*/
$endPoint = "https://test.wikipedia.org/w/api.php";
$login_Token = getLoginToken(); // Step 1
loginRequest( $login_Token ); // Step 2
// Step 1: GET request to fetch login token
function getLoginToken() {
global $endPoint;
$params1 = [
"action" => "query",
"meta" => "tokens",
"type" => "login",
"format" => "json"
];
$url = $endPoint . "?" . http_build_query( $params1 );
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_COOKIEJAR, "/tmp/cookie.txt" );
curl_setopt( $ch, CURLOPT_COOKIEFILE, "/tmp/cookie.txt" );
$output = curl_exec( $ch );
curl_close( $ch );
$result = json_decode( $output, true );
return $result["query"]["tokens"]["logintoken"];
}
// Step 2: POST request to log in. Use of main account for login is not
// supported. Obtain credentials via Special:BotPasswords
// (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
function loginRequest( $logintoken ) {
global $endPoint;
$params2 = [
"action" => "login",
"lgname" => "your_bot_username",
"lgpassword" => "your_bot_password",
"lgtoken" => $logintoken,
"format" => "json"
];
$ch = curl_init();
curl_setopt( $ch, CURLOPT_URL, $endPoint );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, http_build_query( $params2 ) );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_COOKIEJAR, "/tmp/cookie.txt" );
curl_setopt( $ch, CURLOPT_COOKIEFILE, "/tmp/cookie.txt" );
$output = curl_exec( $ch );
curl_close( $ch );
echo( $output );
}
Python
#!/usr/bin/python3
"""
login.py
MediaWiki API Demos
Demo of `Login` module: Sending post request to login
MIT license
"""
import requests
USERNAME = "your_bot_username"
PASSWORD = "your_bot_password"
S = requests.Session()
URL = "https://www.mediawiki.org/w/api.php"
# Retrieve login token first
PARAMS_0 = {
'action':"query",
'meta':"tokens",
'type':"login",
'format':"json"
}
R = S.get(url=URL, params=PARAMS_0)
DATA = R.json()
LOGIN_TOKEN = DATA['query']['tokens']['logintoken']
print(LOGIN_TOKEN)
# Send a post request to login. Using the main account for login is not
# supported. Obtain credentials via Special:BotPasswords
# (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
PARAMS_1 = {
'action': "login",
'lgname': USERNAME,
'lgpassword': PASSWORD,
'lgtoken': LOGIN_TOKEN,
'format': "json"
}
R = S.post(URL, data=PARAMS_1)
DATA = R.json()
print(DATA)
assert DATA['login']['result'] == 'Success'
BASH
#!/usr/bin/env bash
# load config
export MW_PASS="your bot password" # from Special:BotPassword
export MW_USER="your bot name"
export MW_URL="https://www.mediawiki.org/w/" # besure slash at end
# get token
API_URL="api.php"
RESULT=$(curl -fsSL -X POST \
-d action=query \
-d meta=tokens \
-d type=login \
-d format=json \
-c cookie.txt \
-b cookie.txt \
"${MW_URL}${API_URL}")
RESULT=${RESULT/*token\":\"}
TOKEN=${RESULT%\\\"*}
# perform login
RESULT=$(curl -fsSL -X POST \
--data-urlencode action=login \
-d lgname="$MW_USER" \
-d lgpassword="$MW_PASS" \
--data-urlencode lgtoken="$TOKEN" \
-d format=json \
-c cookie.txt \
-b cookie.txt \
"${MW_URL}${API_URL}")
echo $RESULT
Ab MediaWiki 1.27 wird die Nutzung des Hauptkontos für die Anmeldung nicht unterstützt. Erhalte Anmeldeinformationen über Special:BotPasswords oder nutze die Methode
clientlogin. Das Anmelden und angemeldet bleiben erfordert die korrekte Behandlung von HTTP-Cookies durch deinen Client bei allen Abfragen. Im obigen Beispiel zeigen wir, wie ein Sitzungsobjekt requests.Session() dabei hilft, Cookies beizubehalten.
Methode 2. action=clientlogin
Interaktive Anwendungen wie benutzerdefinierte Editoren oder Kontroll-Anwendungen, die einen Service anbieten, ohne die Webseite vollständig ersetzen zu wollen oder mobile Anwendungen, die den Zugriff auf die webbasierte Benutzeroberfläche komplett ersetzen wollen, sollten clientlogin nutzen.
Jedoch sollte die Nutzung von OAuth bevorzugt werden, wenn es möglich ist, das Tool zu authentifizieren, da dies einfacher und sicherer ist.
Dieses Modul ist seit MediaWiki 1.27 verfügbar.
API-Dokumentation
Example: Login using action=clientlogin (MediaWiki 1.27+)
This example demonstrates a minimal client-side login flow using action=clientlogin.
Step 1: Fetch a login token
GET https://www.mediawiki.org/w/api.php?action=query&meta=tokens&type=login&format=json
Step 2: Submit credentials using clientlogin
POST https://www.mediawiki.org/w/api.php
action=clientlogin
&username=ExampleUser
&password=ExamplePassword
&logintoken=LOGIN_TOKEN_FROM_STEP_1
&loginreturnurl=https://example.org/
&format=json
Step 3: Handle the response
If the response status is PASS, the user is logged in successfully.
If the response status is UI or CONTINUE, the client must submit additional fields as instructed in the response (e.g. CAPTCHA or two-factor authentication) and repeat the request using logincontinue.
Beispiel 21: Prozess für ein Wiki ohne spezielle Authentifizierungserweiterungen
POST-Anfrage
api.php?
Das Login-Token in der Abfrage oben wird über API:Tokens erhalten.
Antwort
{
"clientlogin":{
"status":"PASS",
"username":"William"
}
}
Beispielcode
| clientlogin.py |
|---|
#!/usr/bin/python3
"""
clientlogin.py
MediaWiki Action API Code Samples
Demo of `clientlogin` module: Sending post request to login
This demo app uses Flask (a Python web development framework).
MIT license
"""
import requests
from flask import Flask, render_template, flash, request
S = requests.Session()
URL = "https://en.wikipedia.org/w/api.php"
# App config.
DEBUG = True
APP = Flask(__name__)
APP.config.from_object(__name__)
APP.config['SECRET_KEY'] = 'enter_your_secret_key'
@APP.route("/", methods=['GET', 'POST'])
def show_form():
""" Render form template and handle form submission request """
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
start_client_login(username, password)
return render_template('clientlogin_form.html')
def start_client_login(username, password):
""" Send a post request along with login token, user information
and return URL to the API to log in on a wiki """
login_token = fetch_login_token()
response = S.post(url=URL, data={
'action': "clientlogin",
'username': username,
'password': password,
'loginreturnurl': 'http://127.0.0.1:5000/',
'logintoken': login_token,
'format': "json"
})
data = response.json()
if data['clientlogin']['status'] == 'PASS':
flash('Login success! Welcome, ' + data['clientlogin']['username'] + '!')
else:
flash('Oops! Something went wrong -- ' + data['clientlogin']['messagecode'])
def fetch_login_token():
""" Fetch login token via `tokens` module """
response = S.get(
url=URL,
params={
'action': "query",
'meta': "tokens",
'type': "login",
'format': "json"})
data = response.json()
return data['query']['tokens']['logintoken']
if __name__ == "__main__":
APP.run()
|
| form.html |
|---|
<!DOCTYPE html>
<title>MediaWiki Log in</title>
<link rel="stylesheet" href="static/bootstrap/css/bootstrap.min.css">
<div class="container">
<h2>MediaWiki Log in</h2>
<form action="" method="post" role="form">
<div class="form-group">
<div class="form-field">
<div class="label-field">Username</div>
<input name="username">
</div>
<div class="form-field">
<div class="label-field">Password</div>
<input type="password" name="password">
</div>
</div>
<button type="submit" class="btn btn-success">Log in</button>
</form>
<br>
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for message in messages %}
<div class="alert alert-info">
{{ message[1] }}
</div>
{% endfor %}
{% endif %}
{% endwith %}
</div>
<br>
</div>
</div>
|
Beispiel 22: Prozess für ein Wiki mit speziellen Authentifizierungserweiterungen
Ein Wiki mit speziellen Authentifizierungserweiterungen wie BestätigungDerBearbeitung (Captchas), OpenID Connect oder OATHAuth (Zwei-Faktor-Authentifizierung) können einen komplizierteren Authentifizierungsprozess enthalten. In diesem Fall können bestimmte Felder erforderlich sein, deren Beschreibung aus der API:Authmanagerinfo-Abfrage entnommen werden kann.
Schritt 1: Beantwortung des CAPTCHA und Auswahl der OpenID-Authentifikation
Diese Dokumentation ist ein Beispiel und spiegelt nicht das Verhalten einer bestimmten, derzeit verfügbaren OpenID-Erweiterung wider.
Vom Client wird erwartet, den Browser des Benutzers zum bereitgestellten
redirecttarget weiterzuleiten. Der OpenID-Provider würde sich authentifizieren und an Special:OpenIDConnectReturn im Wiki weiterleiten, das die OpenID-Antwort validieren und dann an loginreturnurl weiterleiten würde, das im ersten POST an die API bereitgestellt und um die Parameter code und state ergänzt wurde. Der Client erhält an diesem Punkt die Kontrolle über den Prozess zurück und macht seine nächste API-Anfrage.| Antwort |
|---|
{
"clientlogin": {
"status": "REDIRECT",
"redirecttarget": "https://openid.example.net/openid-auth.php?scope=openid&response_type=code&client_id=ABC&redirect_uri=https://wiki.example.org/wiki/Special:OpenIDConnectReturn&state=XYZ123",
"requests": [
{
"id": "OpenIdConnectResponseAuthenticationRequest",
"metadata": {},
"required": "required",
"provider": "OpenID Connect at example.net",
"account": "",
"fields": {
"code": {
"type": "string",
"label": "OpenID Code",
"help": "OpenID Connect code response"
},
"state": {
"type": "string",
"label": "OpenID State",
"help": "OpenID Connect state response"
},
}
}
]
}
}
|
Schritt 2: Zurück von OpenID
Nun muss der Client die Benutzer bitten, ihre Zwei-Faktor-Authentifizierungs-App für den aktuellen Code zu prüfen und dies zurück an den Server zu übermitteln, um den Authentifizierungsprozess fortzusetzen.
| Antwort |
|---|
{
"clientlogin": {
"status": "UI",
"message": "Two-factor authentication",
"requests": [
{
"id": "TwoFactorAuthenticationRequest",
"metadata": {},
"required": "required",
"provider": "",
"account": "",
"fields": {
"code": {
"type": "string",
"label": "Code",
"help": "Two-factor authentication code"
}
}
}
]
}
}
|
Schritt 3: Zwei-Faktor-Authentifizierung
In bestimmten Fällen ist es möglich, eine
RESTART-Antwort zu erhalten, z. B. wenn die OpenID-Connect-Erweiterung keine Zuordnung des OpenID-Kontos zu einem lokalen Benutzer hat. In diesem Fall kann der Client den Anmeldevorgang von vorn beginnen oder zur Kontoerstellung wechseln, wobei in beiden Fällen der Parameter loginpreservestate oder createpreservestate übergeben wird, um einen bestimmten Zustand zu erhalten.| Antwort |
|---|
{
"clientlogin": {
"status": "PASS",
"username": "Alice"
}
}
|
Mögliche Fehler
| Code | Information |
|---|---|
| Failed | Falscher Benutzername oder falsches Passwort eingegeben. Bitte erneut versuchen. |
| Failed | Du kannst die Anmeldung nicht fortsetzen. Wahrscheinlich wurde deine Sitzung beendet. (oder du handhabst Cookies nicht richtig). |
| WrongToken | Fehlerhaftes Token übergeben |
| NeedToken | `lgtoken` nicht übergeben |
| Aborted | Anmeldung mit dem Hauptpasswort statt mit Botpasswörtern |
| mustpostparams | The following parameters were found in the query string, but must be in the POST body: $1. |
Zusätzliche Anmerkungen
- In Wikis, die eine anonyme Bearbeitung zulassen, ist es möglich, über die API zu schreiben, ohne sich anzumelden. Es wird jedoch dringend empfohlen, dass Sie sich anmelden. In privaten Wikis ist das Einloggen für jede API-Funktionalität erforderlich.
- Es wird empfohlen, ein separates Benutzerkonto für Ihre Anwendung zu erstellen. Dies ist besonders wichtig, wenn Ihre Anwendung eine automatisierte Bearbeitung durchführt oder große oder leistungsintensive Abfragen aufruft. Auf diese Weise ist es einfach, von der Anwendung vorgenommene Änderungen zu verfolgen und Sonderrechte auf das Konto der Anwendung anzuwenden. Das ist besonders wichtig, falls Ihre Anwendung automatisierte Bearbeitungen durchführt oder große bzw. leistungshungrige Abfragen aufruft. So lassen sich die von der Anwendung vorgenommenen Änderungen leicht nachverfolgen und spezielle Rechte auf den Account der Anwendung zuordnen.
- Wenn eine Anfrage gesendet wird, die von einem angemeldeten Benutzer gestellt werden soll, muss der sendenden Anfrage der Parameter
assert=userhinzugefügt werden, um zu prüfen, ob der Benutzer angemeldet ist. Wenn der Benutzer nicht angemeldet ist, wird einassertuserfailedFehlercode zurückgegeben. Für Details, siehe API:Assert - Um zu prüfen, ob das Konto Bot-Rechte hat, füge der Abfrage den Parameter
assert=bothinzu. Wenn der Benutzer keine Bot-Rechte hat, wird ein Fehlercodeassertbotfailedzurückgegeben. Für Details, siehe API:Assert
Siehe auch
- API:Logout
- API:Benutzerinfo – Gibt Informationen über den aktuell angemeldeten Benutzer zurück
- Interaktive Anmeldung mit action=clientlogin in mwapi